#!/bin/sh

#Dieses Script schneidet Filme/Serien von http://www.onlinetvrecorder.de anhand der Schnittlisten von
#http://www.cutlist.at.
#Dies geschieht entweder durch avidemux oder avisplit/avimerge.
#Avidemux schneidet im Gegensatz zu avisplit/avimerge keyframe-genau.
#avisplit/avimerge ist Bestandteil von transcode, avidemux muss separat installiert werden.
#
#Dieses Script darf frei verändert und weitergegeben werden.
#
#Author: Daniel Siegmanski
#Homepage: http://www.siggimania4u.de
#OtrCut Download: http://otrcut.siggimania4u.de
#Source github.com:	https://github.com/adlerweb/otrcut.sh/blob/master/otrcut.sh

#Hier werden verschiedene Variablen definiert.
	version=20160524 #ursprünglich: 20090816 
	LocalCutlistOkay=no #Ist die lokale Cutlist vorhanden?
	input=()	#Eingabedatei/en
	CutProg=""	#Zu verwendendes Schneideprogramm
	LocalCutlistName=""	#Name der lokalen Cutlist
	format=""	#Um welches Format handelt es sich? AVI, HQ, mp4
	cutlistWithError=""	#Cutlists die, einen Fehler haben
	delete=no
	continue=0
#aspect=43 #Standard-Seitenverhältnis
	aspect=169 #Standard-Seitenverhältnis
# decoded=yes # manuell gesetzt, da decode-Funktion deaktiviert

#	Schriftfarben dekativier, um Log in Systemshell besser lesbar zu machen:
	rot=""		#"\033[22;31m"	#Rote Schrift
	gruen=""	#"\033[22;32m"	#Grüne Schrift
	gelb=""		#"\033[22;33m"	#Gelbe Schrift
	blau=""		#"\033[22;34m"	#Blaue Schrift
	normal=""	#"\033[0m"		#Normale Schrift

#Dieses Variablen werden gesetzt, sofern aber ein Config-File besteht wieder überschrieben
	UseLocalCutlist=no #Lokale Cutlists verwenden?
	HaltByErrors=no #Bei Fehlern anhalten?
	toprated=no #Die Cutlist mit der besten User-Bewertung benutzen?
	UseAvidemux=yes #Avidemux verwenden?
	ShowAllCutlists=yes #Auswahl mehrerer Cutlists anzeigen?
	#tmp="/tmp/otrcut"	#Zu verwendender Tmp-Ordner, in diesem Ordner wird dann noch ein Ordner "otrcut" erstellt.

	#tmp="/volume1/homes/admin/script/OTR/tmp"
	appdir=$(cd $(dirname $0);pwd)	# aktuelles Arbeitsverzeichnis auslesen
	tmp="$appdir/tmp/otrcut"
	tmp="$appdir/tmp"

#	workdir=$(cd $(dirname $0);pwd)
	machinetyp=`uname --machine`	#; echo "Architektur:	$machinetyp"
#	dsmbuild=`uname -v | awk '{print $1}' | sed "s/#//g"`; echo "DSM-Build:	$dsmbuild"
#	if [ $machinetyp = "x86_64" ] && [ $dsmbuild -gt 7320 ]; then
	if [ $machinetyp = "x86_64" ] ; then
		# Library Path anpassen:
		export LD_LIBRARY_PATH=$workdir/lib:$LD_LIBRARY_PATH
		appdirbin="$appdir/bin" #:$workdir/app
		bsy="${appdir}/bin/busybox"
	elif [ $machinetyp = "armv7l" ] ; then
		export LD_LIBRARY_PATH=$workdir/libARMv7l:$LD_LIBRARY_PATH
		appdirbin="$appdir/binARMv7l" #:$workdir/app
		bsy="${appdir}/binARMv7l/busybox"
	elif [ $machinetyp = "i686" ] ; then
		appdirbin="$appdir/bin" #:$workdir/app
		bsy="${appdir}/bin/busybox"
	else
		echo "[otrcut.sh:] Deine CPU-Plattform [$machinetyp] wird leider nicht unterstützt …"
	fi



	overwrite=no #Bereits vorhandene Dateien überschreiben
	output=cut #Ausgabeordner
	bewertung=no #Bewertungsfunktion benutzen
	verbose=no #Ausführliche Ausgabe von avidemux bzw. avisplit/avimerge anzeigen
	play=no #Datei nach dem Schneiden wiedergeben
	warn=no #Warnung bezüglich der Löschung von $tmp ausgeben
	user=otrcut #Benutzer der zum Bewerten benutzt wird
	player=mplayer #Mit diesem Player wird das Video wiedergegeben sofern $play auf yes steht
	smart=yes #Force-Smart für avidemux verwenden
	vidcodec=copy #Input-Video nur kopieren.
	personal=no #Persönliche URL von cutlist.at zum Bewerten benutzen
	ad_version=new #New= Avidemux >=2.5, Old= Avidemux <=2.4
	copy=no #Wenn $toprated=yes, und keine Cutlist gefunden wird, $film nach $output kopieren

#Diese Variablen werden vom Benutzer gesetzt.
#Sie sind für die Verwendung des Decoders gedacht.
	email="" #Die EMail-Adresse mit der Sie bei OTR registriert sind
	password="" #Das Passwort mit dem Sie sich bei OTR einloggen
	decoder="otrdecoder" #Pfad zum decoder. Z.B. /home/benutzer/bin/otrdecoder

#Diese Variablen werden vom Benutzer gesetzt.
	personalurl=""	#Die persönliche URL von cutlist.at



# ToDo: Ordner aus Konfiguration.txt übernehmen
#delfolder="/volume1/downloads/#recycle"

if [ -f ~/.otrcut ]; then
		source ~/.otrcut
#	else
#		echo "Keine Config-Datei gefunden, benutze Standardwerte."
fi

#Diese Funktion gibt die Hilfe aus
function help ()
{
cat <<HELP
OtrCut Version: $version

Dieses Script schneidet OTR-Dateien anhand der Cutlist von http://cutlist.at.
Es können entweder die Tools avidemux oder avisplit/avimerge benutzt werden.
Avidemux kann im Gegensatz zu avisplit auch zwischen Keyframes schneiden.
Hier die Anwendung:

$0 [optionen] -i film.mpg.avi

Optionen:

-i, --input [arg] Input Datei/Dateien (kann mehrfach benutzt werden um mehrere Dateien zu schneiden)

-a, --avisplit Avisplit und avimerge anstelle von avidemux verwenden

-e, --error Bei Fehlern das Script beenden

--tmp [arg] TMP-Ordner angeben (Standard: /tmp/), In diesem Ordner wird noch ein Ordner "otrcut" angelegt, ACHTUNG: ALLE Daten in \$tmp werden gelöscht!!!

-l, --local Lokale Cutlists verwenden (Cutlists werden im aktuellen Verzeichnis gesucht)

--delete Quellvideo nach Schneidevorgang löschen ACHTUNG: Falls es sich bei der Quelle um ein OtrKey handelt wird dies auch gelöscht!!!

-o, --output [arg] Ausgabeordner wählen (Standard "./cut")

-ow, --overwrite Schon existierende Ausgabedateien überschreiben

-b, --bewertung Bewertungsfunktion aktivieren

-p, --play Zusammen mit "-b, --bewertung" einsetzbar, startet vor dem Bewerten das Video in einem Videoplayer (Wird in der Variablen \$player definiert)

-w, --warn Warnung bezüglich Löschung aller Dateien in \$tmp unterdrücken

--toprated Verwendet die best bewertetste Cutlist

-v, --verbose Ausführliche Ausgabe von avidemux bzw. avimerge/avisplit aktivieren

--nosmart So wird das --force-smart-Argument für avidemux abgeschaltet.

--personal Die persönliche ID von cutlist.at zum Bewerten benutzen

-av, --avidemux Bei Verwendung von Avidemux <=2.4 muss diese Schalter gesetzt werden.

-c, --copy Wenn $toprated=yes, und keine Cutlist gefunden wird, $film nach $output kopieren

--vcodec [arg] Videocodec (avidemux) spezifizieren. Wenn nicht gesetzt, dann "copy". Mögliche Elemente für [arg]: Divx/Xvid/FFmpeg4/VCD/SVCD/DVD/XVCD/XSVCD/COPY

-h, --help Diese Hilfe ^^

-del Ordner für die gelöschten Dateien

Author: Daniel Siegmanski
Homepage: http://www.siggimania4u.de
Cutlists: http://www.cutlist.de, http://www.cutlist.at

Danke an MKay für das Aspect-Ratio-Script
FPS-Script/HD-Funktion: Florian Knodt <www.adlerweb.info>

HELP
exit 0
}


#Hier werden die übergebenen Option ausgewertet
while [ ! -z "$1" ]; do
	case $1 in
		-i | --input )	input=("${input[@]}" "$2")
				shift ;;
		-a | --avisplit )	UseAvidemux=no ;;
		-e | --error )	HaltByErrors=yes ;;
		-d | --decode )	decode=yes ;;
		--delete )	delete=yes ;;
		-l | --local )	UseLocalCutlist=yes ;;
		-t | --tmp )	tmp=$2
				shift ;;
		-o | --output )	output=$2
				shift ;;
		-ow | --overwrite )	overwrite=yes ;;
		-v | --verbose )	verbose=yes ;;
		-p | --play )	play=yes ;;
		-b | --bewerten)	bewertung=yes ;;
		-w | --warn )	warn=no ;;
		-c | --copy )	copy=yes ;;
		--personal )	personal=yes ;;
		--toprated )	toprated=yes ;;
		--deldir ) 	delfolder=$2 ;;
		--lj ) 	lastjob=$2 ;;
		--messto ) 	MessageTo=$2 ;;
		--wd ) 	synotrconf=$2 ;;
		--nosmart )	smart=no ;;
		--vcodec ) vidcodec="$2"
		                                shift;;
		-av | --avidemux ) ad_version=old ;;
		-h | --help )	help ;;
	esac
	shift
done

echo "OTRcut.sh ==> Nachricht an: ${MessageTo}"





# Konfiguration für synOTR sourcen:
. $synotrconf

# echo "detailierte Ausgabe aktiv: $verbose"

#Diese Funktion gibt die Warnung bezüglich der Löschung von $tmp aus
function warnung ()
{
if [ "$warn" == "yes" ]; then
	echo -e ""
	echo "ACHTUNG!!!"
	echo "Das Script wird alle Dateien in $tmp/otrcut löschen!"
	echo "Sie haben 5 Sekunden um das Script über STRG+C abzubrechen"
	
	for (( I=5; I >= 1 ; I-- )); do
		echo -n "$I "
		sleep 1
	done
	echo -e ""
	echo ""
	echo ""
fi
}

#Diese Funktion gibt einen Hinweis zur Dateinamensübergabe aus
function datei ()
{
echo "ACHTUNG!!!"
echo "Die Eingabedateien müssen entweder ohne führende Verzeichnise "
echo "(z.B. datei.avi, nur wenn Datei im aktuellen Verzeichnis!) oder"
echo "mit dem KOMPLETTEN Pfad (z.B. /home/user/datei.avi) angegeben werden!"
echo -e ""

sleep 2
echo ""
echo ""
}

#Diese Funktion überprüft verschiedene Einstellungen
function test ()
{
#Hier wird überprüft ob eine Eingabedatei angegeben ist
if [ -z "$i" ]; then
		echo "Es wurde keine Eingabedatei angegeben!"
	    exit 1
	else
	    #Überprüfe ob angegebene Datei existiert
	    if [ ! -f "$i" ]; then
			echo -e "Eingabedatei nicht gefunden!"
	        exit 1
	    fi
fi

#Hier wird überprüft ob die Option -p, --play richtig gesetzt wurde
if [ "$play" == "yes" ] && [ "$bewertung" == "no" ]; then
	echo -e "\"Play\" kann nur in Verbindung mit \"Bewertung\" benutzt werden."
	exit 1
fi

#Hier wird überprüft ob der Standard-Ausgabeordner verwendet werden soll.
#Wenn ja, wird überprüft ob er verfügbar ist, wenn nicht wird er erstellt.
#Wurde ein alternativer Ausgabeordner gewählt, wird geprüft ob er vorhanden ist.
#Ist er nicht vorhanden wird gefragt ob er erstellt werden soll.

if [ "$output" == "cut" ]; then
	if [ ! -d "cut" ]; then
		if [ -w $PWD ]; then
				mkdir cut
				echo "Verwende $PWD/cut als Ausgabeordner"
			else
				echo -e "Sie haben keine Schreibrechte im aktuellen Verzeichnis ($PWD)."
				exit 1
		fi
	fi
else
	if [ -d "$output" ] && [ -w "$output" ]; then
		echo "Verwende $output als Ausgabeordner."
	elif [ -d "$output" ] && [ ! -w "$output" ]; then
		echo -e "Sie haben keine Schreibrechte in $output."
		exit 1
	else
		echo -e "Das Verzeichnis $output wurde nicht gefunden, soll er erstellt werden? [y|n]"
		read OUTPUT
		while [ "$OUTPUT" == "" ] || [ ! "$OUTPUT" == "y" ] && [ ! "$OUTPUT" == "n" ]; do #Bei falscher Eingabe
			echo -e "Falsche Eingabe, bitte nochmal:"
			read OUTPUT
		done
		if [ "$OUTPUT" == "n" ]; then	#Wenn der Benutzer nein "sagt"
			echo "Ausgabeverzeichnis \"$output\" soll nicht erstellt werden."
			exit 1
		elif [ "$OUTPUT" == "y" ]; then	#Wenn der Benutzer ja "sagt"
			echo -n "Erstelle Ordner $output -->"
			mkdir "$output"
			if [ -d "$output" ]; then
				echo -e "okay"
			else
				echo -e "false"
				exit 1
			fi
		fi
	fi
fi

#Hier wird überprüft ob der Standard-Tmpordner verwendet werden soll.
#Wenn ja, wird überprüft ob er verfügbar ist, wenn nicht wird er erstellt.
#Wurde ein alternativer Tmpordner gewählt, wird geprüft ob er vorhanden ist.
#Ist er nicht vorhanden wird gefragt ob er erstellt werden soll.
if [ "$tmp" == "/tmp/otrcut" ]; then
	if [ ! -d "/tmp/otrcut" ]; then
		if [ -w "/tmp/otrcut" ]; then
			mkdir "/tmp/otrcut"
			echo "Verwende $tmp als Ausgabeordner"
		else
			echo -e "Sie haben keine Schreibrechte in /tmp/"
			exit 1
		fi
	fi
else
	if [ -d "$tmp/otrcut" ] && [ -w "$tmp" ]; then
#		mkdir "$tmp/otrcut"
		echo "Verwende $tmp/otrcut als tmp-Ausgabeordner."
		tmp="$tmp/otrcut"
	elif [ -d "$tmp" ] && [ ! -w "$tmp" ]; then
		echo -e "${rot}Sie haben keine Schreibrechte in $tmp!${end}"
	else
		echo -e "${gelb}$tmp wurde nicht gefunden, soll er erstellt werden? [y|n]${end}"
		read TMP #Lesen der Benutzereingabe nach $TMP
		while [ "$TMP" == "" ] || [ ! "$TMP" == "y" ] && [ ! "$TMP" == "n" ]; do	#Bei falscher Eingabe
			echo -e "${gelb}Falsche Eingabe, bitte nochmal:${end}"
			read TMP #Lesen der Benutzereingabe nach $TMP
		done
		if [ $TMP == n ]; then	#Wenn der Benutzer nein "sagt"
			echo "Tempverzeichnis \"$tmp\" soll nicht erstellt werden."
			exit 1
		elif [ $TMP == y ]; then	#Wenn der Benutzer ja "sagt"
			echo -n "Erstelle Ordner $tmp --> "
			mkdir "$tmp/otrcut"
			if [ -d "$tmp/otrcut" ]; then
				echo -e "${gruen}okay${end}"
				tmp="$tmp/otrcut"
			else
				echo -e "false"
				exit 1
			fi
		fi
	fi
fi
}

#Diese Funktion überprüft ob avidemux installiert ist
function software ()
{
if [ "$UseAvidemux" == "yes" ]; then
	for s in avidemux2_cli avidemux2_qt4 avidemux2_gtk avidemux2 avidemux; do
		if [ -z $CutProg ]; then
			echo -n "Überprüfe ob $s installiert ist --> "
			if type -t $s >> /dev/null; then
				echo -e "okay"
				CutProg="$s"
			else
				echo -e "false"
			fi
		fi
	done
	if [ -z $CutProg ]; then
		echo -e "Bitte installieren sie avidemux, oder verwenden sie die Optione \"-a\"!"
		exit 1
	fi
fi

#Hier wird überprüft ob avisplit und avimerge installiert sind
if [ "$UseAvidemux" == "no" ]; then
	for p in $appdirbin/avisplit $appdirbin/avimerge; do
	#for p in avisplit avimerge; do
		echo -n "Überprüfe ob $p installiert ist --> "
		#if type -t $p >> $appdirbin; then
		if type -t $p >> /dev/null; then
			echo -e "okay"
			CutProg="avisplit"
		else
			echo -e "false"
			echo -e "Installieren Sie transcode!"
			exit 1
		fi
	done
fi


#Hier wird ueberprueft ob date zum umrechnen der Zeit benutzt werden kann
echo -n "Überpruefe welche Methode zum Umrechnen der Zeit benutzt wird --> "
date_var=$(date -u -d @120 +%T 2>/dev/null)
if [ "$date_var" == "00:02:00" ]; then
	echo -e "date"	 ; date_okay=yes
else
	echo -e "intern" ; date_okay=no
fi


#Hier wird überprüft ob der richtige Pfad zum Decoder angegeben wurde
if [ "$decoded" == "yes" ]; then
	echo -n "Überprüfe ob der Decoder-Pfad richtig gesetzt wurde --> "
	if $decoder -v >> /dev/null; then
		echo -e "okay"
	else
		echo -e "false"
		exit 1
	fi
	if [ "$email" == "" ]; then
		echo -e "EMail-Adresse wurde nicht gesetzt."
		exit 1
	fi
	if [ "$password" == "" ]; then
		echo -e "Passwort wurde nicht gesetzt."
		exit 1
	fi
fi
}

#Diese Funktion definiert den Cutlist- und Dateinamen und üperprüft um welches Dateiformat es sich handelt
function name ()
{
film=$i	#Der komplette Filmname und gegebenfalls der Pfad
film_ohne_anfang=$i
#Für Avidemux <=2.5 muss der komplette Pfad angegeben werden
if [ "$ad_version" == "new" ]; then
	film_var=${film#/}
	output_var=${output#/}
	if [ "$film" == "$film_var" ]; then
		film_new_ad="$PWD/$film"
	else
		film_new_ad="$film"
	fi
	if [ "$output" == "$output_var" ]; then
		output="$PWD/$output"
	fi
fi
if [ "$decoded" == "yes" ]; then
	film_ohne_anfang="${film_ohne_anfang%%.otrkey}"
	film_ohne_anfang="${film_ohne_anfang##*/}"
	film="$film_ohne_anfang"
fi
CUTLIST=`basename "$film"`	#Filmname ohne Pfad
echo -n "Überprüfe um welches Aufnahmeformat es sich handelt --> "
if echo "$film_ohne_anfang" | grep -q ".HQ."; then	#Wenn es sich um eine "HQ" Aufnahme handelt
	film_ohne_ende=${film%%.mpg.HQ.avi}	#Filmname ohne Dateiendung
	CUTLIST=${CUTLIST/.avi/}.cutlist #Der lokale Cutlistname
	format=hq
	echo -e "HQ"
elif echo "$film_ohne_anfang" | grep -q ".mp4"; then	#Wenn es sich um eine "mp4" Aufnahme handelt
	film_ohne_ende=${film%%.mpg.mp4}	#Filmname ohne Dateiendung
	format=mp4
	CUTLIST=${CUTLIST/.mp4/}.cutlist #Der lokale Cutlistname
	echo -e "mp4"
else
	film_ohne_ende=${film%%.mpg.avi}	#Filmename ohne Dateiendung
	format=avi
	CUTLIST=${CUTLIST/.avi/}.cutlist #Der lokale Cutlistname
	echo -e "avi"
fi

if echo "$film" | grep / >> /dev/null; then	#Wenn der Dateiname einen Pfad enthält
	film_ohne_anfang=${film##*/}	#Filmname ohne Pfad
	if echo "$film_ohne_anfang" | grep -q ".HQ."; then	#Wenn es sich um eine "HQ" Aufnahme handelt
		film_ohne_ende=${film_ohne_anfang%%.mpg.HQ.avi}
		format=hq
	elif echo "$film_ohne_anfang" | grep -q ".mp4"; then	#Wenn es sich um eine "mp4" Aufnahme handelt
		film_ohne_ende=${film_ohne_anfang%%.mpg.mp4}
		format=mp4
	else
		film_ohne_ende=${film_ohne_anfang%%.mpg.avi}
		format=avi
	fi
fi

if echo "$film_ohne_anfang" | grep -q ".HQ."; then
	outputfile="$output/$film_ohne_ende.HQ-cut.avi"
elif echo "$film_ohne_anfang" | grep -q ".mp4"; then
	outputfile="$output/$film_ohne_ende-cut.mp4"
else
	outputfile="$output/$film_ohne_ende-cut.avi"
fi
}

#In dieser Funktion wird die lokale Cutlist überprüft
function local ()
{
local_cutlists=$(ls *.cutlist)	#Variable mit allen Cutlists in $PWD
filesize=$(ls -l "$film" | awk '{ print $5 }') #Dateigröße des Filmes
let goodCount=0 #Passende Cutlists
let arraylocal=1 #Nummer des Arrays
for f in $local_cutlists; do
	echo -n "Überprüfe ob eine der gefundenen Cutlists zum Film passt --> "
	if [ -z $f ]; then
		echo -e "Keine Cutlist gefunden!"
		if [ "$HaltByErrors" == "yes" ]; then
			exit 1
		else
			vorhanden=no
			continue=1
		fi
	fi
		
	OriginalFileSize=$(cat $f | grep OriginalFileSizeBytes | cut -d"=" -f2 | /usr/bin/tr -d "\r")	#Dateigröße des Films
	
	if cat $f | grep -q "$film"; then	#Wenn der Dateiname mit ApplyToFile übereinstimmt
		echo -e -n "ApplyToFile "
		ApplyToFile=yes
		vorhanden=yes
	fi
	if [ "$OriginalFileSize" == "$filesize" ]; then	#Wenn die Dateigröße mit OriginalFileSizeBytes übereinstimmt
		echo -e -n "OriginalFileSizeBytes"
		OriginalFileSizeBytes=yes
		vorhanden=yes
	fi
	if [ "$vorhanden" == "yes" ]; then	#Wenn eine passende Cutlist vorhanden ist
		let goodCount++
		namelocal[$arraylocal]="$f"
		#echo $f
		#echo ${namelocal[$arrylocal]}
		let arraylocal++
		continue=0
	else
		echo -e "false"
	fi
done

if [ "$goodCount" -eq 1 ]; then	#Wenn nur eine Cutlist gefunden wurde
	echo "Es wurde eine passende Cutlist gefunden. Diese wird nun verwendet."
	CUTLIST="$f"
	cp "$CUTLIST" "$tmp"
elif [ "$goodCount" -gt 1 ]; then	#Wenn mehrere Cutlists gefunden wurden
	echo "Es wurden $goodCount Cutlists gefunden. Bitte wählen Sie aus:"
	echo ""
	let number=1
	for (( i=1; i <= $goodCount ; i++ )); do
		echo "$number: ${namelocal[$number]}"
		let number++
	done
	echo -n "Bitte die Nummer der zu verwendenden Cutlist eingeben:"
	read NUMBER
	while [ "$NUMBER" -gt "$goodCount" ]; do
		echo "false. Noch mal:"
		read NUMBER
	done
	echo "Verwende ${namelocal[$NUMBER]} als Cutlist."
	CUTLIST=$namelocal[$NUMBER]
	cp "$CUTLIST" "$tmp"
	vorhanden=yes
fi
}

#In dieser Funktion wird versucht eine Cutlist aus den Internet zu laden
function load ()
{
#In dieser Funktion wird geprüft, ob die Cutlist okay ist
function test_cutlist ()
{
	let cutlist_size=$(ls -l "$tmp/$CUTLIST" | awk '{ print $5 }')
	if [ "$cutlist_size" -lt "100" ]; then
		cutlist_okay=no
		rm -rf "$TMP/$CUTLIST"
	else
		cutlist_okay=yes
	fi
}

if [ "$personal" == "yes" ]; then
	server=$personalurl
else
	server="http://cutlist.at/"
fi

#echo $server

echo -e "Bearbeite folgende Datei: $film"
sleep 1
if [ "$decoded" == "yes" ]; then
	filesize=$(ls -l "$output/$film" | awk '{ print $5 }')
else
	filesize=$(ls -l "$film" | awk '{ print $5 }')
fi
echo "Dateigröße = $filesize Byte"
echo -n "Führe Suchanfrage anhand der Dateigröße bei \"cutlist.at\" durch ---> "
wget -q -O "$tmp/search.xml" "${server}getxml.php?version=0.9.8.0&ofsb=$filesize" &&

if grep -q '<id>' "$tmp/search.xml"; then
	echo -e "okay"
else
	echo "Keine Cutlist anhand der Dateigröße gefunden!"
	echo -n "Führe Suchanfrage anhand des Dateinamens bei \"cutlist.at\" durch ---> "
	filmdateiname=`basename $film`
	wget -q -O "$tmp/search.xml" "${server}getxml.php?version=0.9.8.0&name=$filmdateiname" &&
	if grep -q '<id>' "$tmp/search.xml"; then
		echo -e "okay"
	else
# HD-Film: suche SD-Cutlist ==> geht nicht (hängt wahrscheinlich mit den fps und Cutumrechnung zusammen)
#		filmdateiname_ohneHD=`echo $filmdateiname | sed "s/.HD//g"`
#		wget -q -O "$tmp/search.xml" "${server}getxml.php?version=0.9.8.0&name=$filmdateiname_ohneHD" &&
#		if grep -q '<id>' "$tmp/search.xml"; then
#			echo -e "okay [SD-Cutlist gefunden]"
#		else
			echo -e "Keine Cutlist anhand des Dateinamens gefunden!"
			if [ "$HaltByErrors" == "yes" ]; then
				exit 1
			else
				continue=1
			fi
#		fi
	fi
fi


#Hier wird die Suchanfrage überprüft
if [ "$continue" == "1" ]; then
	echo -e "Es wurden keine Cutlists auf cutlist.at gefunden."
	if [ "$HaltByErrors" == "yes" ]; then
		exit 1
	elif [ "$toprated" == "no" ] && [ "$copy" == "no" ]; then
		continue=1
		echo -e "Soll \"$film\" in den Ausgabeordner kopiert erden? [y|n]"
		read COPY
		while [ "$COPY" == "" ] || [ ! "$COPY" == "y" ] && [ ! "$COPY" == "n" ]; do #Bei falscher Eingabe
			echo -e "Falsche Eingabe, bitte nochmal:"
			read COPY
		done
		if [ "$COPY" == "n" ]; then		#Wenn der Benutzer nein "sagt"
			echo "Datei wird nicht kopiert."
		elif [ "$COPY" == "y" ]; then	#Wenn der Benutzer ja "sagt"
			echo "Datei wird in den Ausgabeordner kopiert."
			cp "$film" "$output/"
		fi
	elif [ "$copy" == "yes" ]; then
		echo "Datei wird in den Ausgabeordner kopiert."
		cp "$film" "$output/"
	fi
else
	if [ "$schon_mal_angezeigt" == "" ]; then
		echo -e "Cutlist/s gefunden."
		echo ""
		echo "Es wurden folgende Cutlists gefunden:"
		schon_mal_angezeigt=yes
		let array=0
	fi
	cutlist_anzahl=$(grep -c '/cutlist' "$tmp/search.xml" | /usr/bin/tr -d "\r") #Anzahl der gefundenen Cutlists
	let cutlist_anzahl
	if [ "$cutlist_anzahl" -ge "1" ] && [ "$continue" == "0" ]; then #Wenn mehrere Cutlists gefunden wurden
		echo ""
		let tail=1
		while [ "$cutlist_anzahl" -gt "0" ]; do
		#Name der Cutlist
		name[$array]=$(grep "<name>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Author der Cutlist
		author[$array]=$(grep "<author>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Bewertung des Authors
		ratingbyauthor[$array]=$(grep "<ratingbyauthor>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Bewertung der User
		rating[$array]=$(grep "<rating>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Kommentar des Authors
		comment[$array]=$(grep "<usercomment>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#ID der Cutlist
		ID[$array]=$(grep "<id>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Anzahl der Bewertungen
		ratingcount[$array]=$(grep "<ratingcount>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Cutangaben in Sekunden
		cutinseconds[$array]=$(grep "<withtime>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Cutangaben in Frames (besser)
		cutinframes[$array]=$(grep "<withframes>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")
		#Filename der Cutlist
		filename[$array]=$(grep "<filename>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | /usr/bin/tr -d "\r")

		if [ "$toprated" == "no" ]; then #Wenn --toprated nicht gesetzt ist
			if echo $cutlistWithError | grep -q "${ID[$array]}"; then #Wenn Fehler gesetzt ist z.B. EPG-Error oder MissingBeginning
				echo -ne "${rot}"
			fi
			echo -n "[$array]"
			echo " Name: ${name[$array]}"
			echo " Author: ${author[$array]}"
			echo " Rating by Author: ${ratingbyauthor[$array]}"
			if [ -z "$cutlistWithError" ]; then
				echo -ne "${gruen}"
			fi
			echo " Rating by Users: ${rating[$array]} @ ${ratingcount[$array]} Users"
			if [ -z "$cutlistWithError" ]; then
				echo -ne "${normal}"
			fi
			if [ "${cutinframes[$array]}" == "1" ]; then
				echo " Cutangabe: Als Frames"
			fi
			if [ "${cutinseconds[$array]}" == "1" ] && [ ! "${cutinframes[$array]}" == "1" ]; then
				echo " Cutangabe: Als Zeit"
			fi
			echo " Kommentar: ${comment[$array]}"
			echo " Filename: ${filename[$array]}"
			echo " ID: ${ID[$array]}"
			#echo " Server: ${server[$array]}"
			echo ""
			if echo $cutlistWithError | grep -q "${ID[$array]}"; then #Wenn Fehler gesetzt ist z.B. EPG-Error oder MissingBeginning
			echo -ne "${normal}"
			fi
		fi
		let tail++
		let cutlist_anzahl--
		let array++
		array1=array
		done

		if [ "$toprated" == "yes" ]; then # Wenn --toprated gesetzt wurde
			if [ "$angezeigt" == "" ]; then
				echo "Lade die Cutlist mit der besten User-Bewertung herunter."
				angezeigt=yes
			fi
			let array1--
			while [ $array1 -ge 0 ]; do
				rating1[$array1]=${rating[$array1]}	
				if [ "${rating1[$array1]}" == "" ]; then	#Wenn keine Benutzerwertung abgegeben wurde
					rating1[$array1]="0.00"	#Schreibe 0.00 als Bewertung
				fi
				rating1[$array1]=$(echo ${rating1[$array1]} | sed 's/\.//g')	#Entferne den Dezimalpunkt aus der Bewertung. 4.50 wird zu 450
				#echo "Rating ohne Komma: ${rating1[$array1]}"
				let array1--
			done
			numvalues=${#rating1[@]}	#Anzahl der Arrays
            for (( i=0; i < numvalues; i++ )); do
				lowest=$i
				for (( j=i; j < numvalues; j++ )); do
					if [ ${rating1[j]} -ge ${rating1[$lowest]} ]; then
						lowest=$j
					fi
				done
				temp=${rating1[i]}
			    rating1[i]=${rating1[lowest]}
			    rating1[lowest]=$temp
		     done
			bigest=${rating1[0]}

            beste_bewertung=${bigest%%??}	#Die beste Wertung ohne Dezimalpunkt
            beste_bewertung_punkt=$beste_bewertung.${bigest##?}	#Die beste Wertung mit Dezimalpunkt
		fi
	fi
fi

if [ "$toprated" == "yes" ] && [ "$continue" == "0" ]; then
	bereits_toprated=no
	echo "Die beste Bewertung ist: $beste_bewertung"
	bereits_toprated=yes

	if [ "$beste_bewertung" == "0" ]; then
		beste_bewertung="</rating>"
	fi

	cutlist_nummer=$(grep "<rating>" "$tmp/search.xml" | grep -n "<rating>$beste_bewertung" | cut -d: -f1 | head -n1)
	id=$(grep "<id>" "$tmp/search.xml" | head -n$cutlist_nummer | tail -n1 | cut -d">" -f2 | cut -d"<" -f1) #ID der best bewertetsten Cutlist
	let num=$cutlist_nummer-1
	id_downloaded=$(echo ${ID[$num]})
	CUTLIST=$(grep "<name>" "$tmp/search.xml" | cut -d">" -f2 | cut -d"<" -f1 | head -n$cutlist_nummer | tail -n1 | /usr/bin/tr -d "\r") #Name der Cutlist
fi

if [ "$toprated" == "no" ] && [ "$continue" == "0" ]; then
	let array_groesse=$array
	let array_groesse--
	CUTLIST_ZAHL=""
	while [ "$CUTLIST_ZAHL" == "" ]; do #Wenn noch keine Cutlist gewählt wurde
		echo -n "Bitte die Nummer der zu verwendenden Cutlist eingeben: "
		read CUTLIST_ZAHL #Benutzereingabe lesen
		if [ -z "$CUTLIST_ZAHL" ]; then
			echo -e "Ungültige Auswahl."
			CUTLIST_ZAHL=""
		elif [ "$CUTLIST_ZAHL" -gt "$array_groesse" ]; then
			echo -e "Ungültige Auswahl."
			CUTLIST_ZAHL=""
		fi
	done
	let array_groesse=$CUTLIST_ZAHL
	let CUTLIST_ZAHL++
	id=$(grep "<id>" "$tmp/search.xml" | tail -n$CUTLIST_ZAHL | head -n1 | cut -d">" -f2 | cut -d"<" -f1)
	let num=$CUTLIST_ZAHL-1
	id_downloaded=$(echo ${id[$num]})
	CUTLIST=$(grep "<name>" "$tmp/search.xml" | tail -n$CUTLIST_ZAHL | head -n1 | cut -d">" -f2 | cut -d"<" -f1)
fi

if [ "$continue" == "0" ]; then
	echo -n "Lade $CUTLIST --> "
	#echo $id
	wget -q -O "$tmp/$CUTLIST" "${server}getfile.php?id=$id"
	test_cutlist #Testen der Cutlist
	if [ -f "$tmp/$CUTLIST" ] && [ "$cutlist_okay" == "yes" ]; then
		echo -e "okay"
		continue=0
	else
		echo -e "false"
		if [ "$HaltByErrors" == "yes" ]; then
			exit 1
		else
			continue=1
		fi
	fi
fi
}


#Hier wird überprüft um welches Cutlist-Format es sich handelt
function format ()
{
	echo -n "Überprüfe um welches Format es sich handelt --> "
	if cat "$tmp/$CUTLIST" | grep "StartFrame=" >> /dev/null; then
		echo -e "Frames"
		format=frames
		elif cat "$tmp/$CUTLIST" | grep "Start=" >> /dev/null; then
			echo -e "Zeit"
			format=zeit
		else
			echo -e "false"
			echo -e "Wahrscheinlich wurde das Limit von cutlist.de überschritten!"
		if [ "$HaltByErrors" == "yes" ]; then
			exit 1
		else
			continue=1
		fi
	fi
 }

#Hier wir die Cutlist überprüft, auf z.B. EPGErrors, MissingEnding, MissingVideo, ...
function cutlist_error ()
{
#Diese Variable beinhaltet alle möglichen Fehler
errors="EPGError MissingBeginning MissingEnding MissingVideo MissingAudio OtherError"
for e in $errors; do
	error_check=$(cat "$tmp/$CUTLIST" | grep -m1 $e | cut -d"=" -f2 | /usr/bin/tr -d "\r")
	if [ "$error_check" == "1" ]; then
		echo -e "Es wurde ein Fehler gefunden: \"$e\""
		error_yes=$e
		if [ "$error_yes" == "OtherError" ]; then
			othererror=$(cat "$tmp/$CUTLIST" | grep "OtherErrorDescription")
			othererror=${othererror##*=}
			echo -e "Grund für \"OtherError\": \"$othererror\""
		fi
		if [ "$error_yes" == "EPGError" ]; then
			epgerror=$(cat "$tmp/$CUTLIST" | grep "ActualContent")
			epgerror=${epgerror##*=}
			echo -e "${rot}ActualContent: $epgerror${end}"
		fi
		error_found=1
		cutlistWithError="${cutlistWithError} $id_downloaded"
		#echo $cutlistWithError
	fi
done
}

#Hier wird geprüft, welches Seitenverhältnis der Film hat.
#Danke hierfür an MKay aus dem OTR-Forum
function aspectratio ()
{
echo -n "ermitteltes Seitenverhältnis --> "

aspectR=$(
mplayer -vo null -nosound "$film" 2>&1 |
while read line; do	# Warten bis mplayer aspect-infos liefert oder anfaengt zu spielen
	if [[ $line == "Movie-Aspect is 1.33:1"* ]] || [[ "$line" == "Film-Aspekt ist 1.33:1"* ]]; then
		echo 1
		break
	fi
	if [[ $line == "Movie-Aspect is 0.56:1"* ]] || [[ "$line" == "Film-Aspekt ist 0.56:1"* ]]; then
		echo 2
		break
	fi
	if [[ $line == "Movie-Aspect is 1.78:1"* ]] || [[ "$line" == "Film-Aspekt ist 1.78:1"* ]]; then
		echo 2
		break
	fi
	if [[ $line == "VO: [null]"* ]] ; then
		echo 0
		break
	fi
done
)

#echo $aspectR

if [ "$aspectR" -eq 0 ] ; then
	echo -e "false"
	if [ "$smart" == "no" ]; then
		aspect=169
	else
		echo -n "Soll der 16:9-Modus verwendet werden? [y|N]? "
		read ASPECT
		if [ "$ASPECT" == "y" ]; then
			aspect=169
			echo "Benutze 16:9-Modus"
		else
			aspect=43
			echo "Benutze den normalen Modus."
		fi
	fi
fi
if [ $aspectR -eq 1 ] ; then
	echo -e "4:3"
	aspect=43
fi
if [ $aspectR -eq 2 ] ; then
	echo -e "16:9"
	aspect=169
fi
}

#Hier wird geprüft, welche Bildrate der Film hat.
#Florian Knodt <www.adlerweb.info>
function fps ()
{
#echo -n "Ermittles Bildrate --> "

fps=50
if file "$film" 2>&1 | grep "25.00 fps" > /dev/null ; then
	fps=25
fi
#echo $fps
}

#Hier wird nun die Zeit ins richtige Format für avisplit umgerechnet
function time1 ()
{
time=""
let cut_anzahl=$(cat "$tmp/$CUTLIST" | grep "NoOfCuts" | cut -d"=" -f2 | /usr/bin/tr -d "\r")
echo "####Auflistung der Cuts####"
if [ "$format" == "zeit" ]; then	#Wenn das verwendete Format "Zeit" ist
	let head1=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden."
	while [ "$cut_anzahl" -gt "0" ]; do
		#Die Sekunde in der der Cut beginnen soll
		let time_seconds_start=$(cat "$tmp/$CUTLIST" | grep "Start=" | cut -d"=" -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 | /usr/bin/tr -d "\r")
		echo "Startcut: $time_seconds_start. Sekunde"
		time=${time}$(date -u -d @$time_seconds_start +%T-)	#Die Sekunden umgerechned in das Format hh:mm:ss
		#Wie viele Sekunden der Cut dauert
		let time_seconds_ende=$(cat "$tmp/$CUTLIST" | grep "Duration=" | cut -d"=" -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 | /usr/bin/tr -d "\r")
		let time_seconds_ende=$time_seconds_ende+$time_seconds_start	#Die Sekunde in der der Cut endet
		echo "Endcut: $time_seconds_ende. Sekunde"
		time=${time}$(date -u -d @$time_seconds_ende +%T,)	#Die Endsekunde im Format hh:mm:ss
		let head1++
		let cut_anzahl--
		#In der Variable $time sind alle Cuts wie folgt aufgelistet:
		#hh:mm:ss-hh:mm:ss,hh:mm:ss-hh:mm:ss,...
	done
elif [ "$format" == "frames" ]; then	#Wenn das verwendete Format "Frames" ist
	let head1=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden."
	while [ $cut_anzahl -gt 0 ]; do
		#Der Frame bei dem der Cut beginnt
		let startframe=$(cat "$tmp/$CUTLIST" | grep "StartFrame=" | cut -d= -f2 | head -n$head1 | tail -n1 | /usr/bin/tr -d "\r")
		echo "Startframe= $startframe"
		time="${time}$startframe-"
		#Wie viele Frames dauert der Cut
		let stopframe=$(cat "$tmp/$CUTLIST" | grep "DurationFrames=" | cut -d= -f2 | head -n$head1 | tail -n1 | /usr/bin/tr -d "\r")
		let stopframe=$stopframe+$startframe	#Der Frame bei dem der Cut endet
		echo "Endframe= $stopframe"
		time="${time}$stopframe,"	#Auflistung alles Cuts
		let head1++
		let cut_anzahl--
		#In der Variable $time sind alle Cuts wie folgt aufgelistet:
		#StartFrame-EndFrame,StartFrame-EndFrame,...
	done
fi
echo "####ENDE####" ; echo -e
sleep 1
}

#Hier wird nun die Zeit ins richtige Format für avisplit umgerechnet, falls die date-Variante nicht funktioniert
function time2 ()
{
time=""
let cut_anzahl=$(cat "$tmp/$CUTLIST" | grep "NoOfCuts" | cut -d= -f2 | /usr/bin/tr -d "\r")
echo "#####Auflistung der Cuts#####"
if [ $format == "zeit" ]; then
	let head1=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
	while [ $cut_anzahl -gt 0 ]; do
		#Die Sekunde in der der Cut startet
		let time_seconds_start=$(cat "$tmp/$CUTLIST" | grep "Start=" | cut -d= -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 | /usr/bin/tr -d "\r")
		let ss=$time_seconds_start	#Setze die Skunden auf $time_seconds_start
		let mm=0 #Setze die Minuten auf 0
		let hh=0 #Setze die Stunden auf 0
		while [ $ss -ge "60" ]; do	#Wenn die Sekunden >= 60 sind
			let mm++ #Zähle Minuten um 1 hoch
			let ss=$ss-60 #Zähle Sekunden um 60 runter
			while [ $mm -ge "60" ]; do	#Wenn die Minuten >= 60 sind
				let hh++ #Zähle Stunden um 1 hoch
				let mm=$mm-60 #Zähle Minuten um 60 runter
			done
		done
		time2_start=$hh:$mm:$ss	#Bringe die Zeit ins richtige Format
		echo "Startcut=	$time2_start"
		time="${time}${time2_start}-"	#Auflistung aller Zeiten
		#Sekunden wie lange der Cut dauert
		let time_seconds_ende=$(cat "$tmp/$CUTLIST" | grep "Duration=" | cut -d= -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 | /usr/bin/tr -d "\r")
		let time_seconds_ende=$time_seconds_ende+$time_seconds_start	#Die Sekunde in der der Cut endet
		let ss=$time_seconds_ende	#Setze die Sekunden auf $time_seconds_ende
		let mm=0 #Setze die Minuten auf 0
		let hh=0 #Setze die Stunden auf 0
		while [ $ss -ge "60" ]; do	#Wenn die Sekunden >= 60 sind
			let mm++ #Zähle Minuten um 1 hoch
			let ss=$ss-60 #Zähle Sekunden um 60 runter
			while [ $mm -ge "60" ]; do	#Wenn die Minuten >= 60 sind
				let hh++ #Zähle Stunden um 1 hoch
				let mm=$mm-60 #Z#hle Minuten um 60 runter
			done
		done
		time2_ende=$hh:$mm:$ss	#Bringe die Zeit ins richtige Format
		echo "Endcut=		$time2_ende"
		time="${time}${time2_ende},"	#Auflistung alles Zeiten
		let head1++ #neu
		let cut_anzahl-- #neu
	done
elif [ $format == "frames" ]; then
	let head1=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
	while [ $cut_anzahl -gt 0 ]; do
		#Der Frame bei dem der Cut beginnt
		let startframe=$(cat "$tmp/$CUTLIST" | grep "StartFrame=" | cut -d= -f2 | head -n$head1 | tail -n1 | /usr/bin/tr -d "\r")
		echo "Startframe=	$startframe"
		time="${time}$startframe-"	#Auflistung der Cuts
		#Die Frames wie lange der Cut dauert
		let stopframe=$(cat "$tmp/$CUTLIST" | grep "DurationFrames=" | cut -d= -f2 | head -n$head1 | tail -n1 | /usr/bin/tr -d "\r")
		let stopframe=$stopframe+$startframe	#Der Frame bei dem der Cut endet
		echo "Endframe=	$stopframe"
		time="${time}$stopframe,"	#Auflistung der Cuts
		let head1++
		let cut_anzahl--
	done
fi
echo "#####ENDE#####" ; echo -e
sleep 1
}

#Hier wird nun, falls aviplit/avimerge gewählt wurde, avisplit und avimerge gestartet
function split ()
{
echo "Übergebe die Cuts an avisplit/avimerge"

if [ $decoded == "yes" ]; then
#		$appdirbin/nice -n 15 
		$appdirbin/avisplit -i "$output/$film" -o "$outputfile" -t $time -c  1>/dev/null #Hier wird avisplit gestartet, avimerge wird on-the-fly über den Parameter -c gestartet
	else
#		$appdirbin/nice -n 15 
		$appdirbin/avisplit -i "$film" -o "$outputfile" -t $time -c  1>/dev/null #Hier wird avisplit gestartet, avimerge wird on-the-fly über den Parameter -c gestartet
fi
if [ -f "$outputfile" ]; then
	echo -e "$outputfile wurde erstellt"
	
	# DSM Benachrichtigung:
	if [ $OTRrenameactiv = "on" ] ; then
			lastjob=4
		elif [ $OTRavi2mp4active = "on" ] ; then
			lastjob=3
		elif [ $OTRcutactiv = "on" ] ; then
			lastjob=2
		else
			lastjob=1
	fi
	filedestname=`basename $outputfile`
	
	if [ $lastjob -eq 2 ] ; then
		if [ $dsmtextnotify = "on" ] ; then
			synodsmnotify @$MessageTo "synOTR" "$filedestname ist fertig"
		fi
		if [ $dsmbeepnotify = "on" ] ; then
				echo 2 > /dev/ttyS1 #short beep
		fi
		wget -q -O - "http://geimist.eu/synOTR/synOTR_FILECOUNT" >/dev/null 2>&1
	fi	

	if [ "$delete" == "yes" ]; then
		echo "Lösche Quellvideo."
		if [ $decoded == "yes" ]; then
#				$appdirbin/nice -n 15 
				rm -rf "$output/$film"
			else
				#$appdirbin/nice -n 15 rm -rf "$film"
#				$appdirbin/nice -n 15 
				mv "$film" "$delfolder"
		fi
	fi
else
	echo -e "Avisplit oder avimerge muss einen Fehler verursacht haben."
	if [ "$HaltByErrors" == "yes" ]; then
		exit 1
	else
		continue=1
	fi
fi
}

#Hier wird nun, fals avidemux gewählt wurde, avidemux gestartet
function demux ()
{
#In dieser Funktion wird der Projektanfang definiert
function start1 ()
{
cat << EOF
//AD <- Needed to identify//
var app = new Avidemux();

//** Video **
// 01 videos source
EOF
}

#Schreibe die Ausgabe von start in eine Datei
start1 >> "$tmp/avidemux.js"

if [ "$ad_version" == "old" ]; then
	if [ "$decoded" == "yes" ]; then
		echo "app.load(\"$output/$film\")" >> "/$tmp/avidemux.js"
	else
		echo "app.load(\"$film\")" >> "/$tmp/avidemux.js"
	fi
elif [ "$ad_version" == "new" ]; then
	if [ "$decoded" == "yes" ]; then
		echo "app.load(\"$output_new/$film\")" >> "/$tmp/avidemux.js"
	else
		echo "app.load(\"$film_new_ad\")" >> "/$tmp/avidemux.js"
	fi
fi

function start2 ()
{
cat << EOF
//$cut_anzahl segments
app.clearSegments();
EOF
}
#Schreibe die Ausgabe von start in eine Datei
start2 >> "$tmp/avidemux.js"

let cut_anzahl=$(cat "$tmp/$CUTLIST" | grep "NoOfCuts" | cut -d= -f2 | /usr/bin/tr -d "\r")
echo "#####Auflistung der Cuts#####"
if [ "$format" = "zeit" ]; then
	let head2=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
	while [ "$cut_anzahl" -gt 0 ]; do
		let time_seconds_start=$(cat "$tmp/$CUTLIST" | grep "Start=" | cut -d= -f2 | head -n$head2 | tail -n1 | cut -d"." -f1 | /usr/bin/tr -d "\r")
		let time_frame_start=$time_seconds_start*$fps
		echo "Startframe= $time_frame_start"
		let time_seconds_dauer=$(cat "$tmp/$CUTLIST" | grep "Duration=" | cut -d= -f2 | head -n$head2 | tail -n1 | cut -d"." -f1 | /usr/bin/tr -d "\r")
		let time_frame_dauer=$time_seconds_dauer*$fps
		echo "Dauer= $time_frame_dauer"
		echo "app.addSegment(0,$time_frame_start,$time_frame_dauer);" >> "$tmp/avidemux.js"
		let head2++
		let cut_anzahl--
	done
elif [ "$format" = "frames" ]; then
	let head2=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
	while [ $cut_anzahl -gt 0 ]; do
		let startframe=$(cat "$tmp/$CUTLIST" | grep "StartFrame=" | cut -d= -f2 | head -n$head2 | tail -n1 | /usr/bin/tr -d "\r")
		echo "Startframe= $startframe"
		let dauerframe=$(cat "$tmp/$CUTLIST" | grep "DurationFrames=" | cut -d= -f2 | head -n$head2 | tail -n1 | /usr/bin/tr -d "\r")
		echo "Dauer= $dauerframe"
		echo "app.addSegment(0,$startframe,$dauerframe);" >> "$tmp/avidemux.js"
		let head2++
		let cut_anzahl--
	done
fi

echo "#####ENDE#####"
sleep 1

if [ "$ad_version" == "old" ]; then
	if echo "$film_ohne_anfang" | grep -q ".HQ."; then
		outputfile="$output/$film_ohne_ende.HQ-cut.avi"
	elif echo "$film_ohne_anfang" | grep -q ".mp4"; then
		outputfile="$output/$film_ohne_ende-cut.mp4"
	else
		outputfile="$output/$film_ohne_ende-cut.avi"
	fi
else
	if echo "$film_ohne_anfang" | grep -q ".HQ."; then
		outputfile="$output/$film_ohne_ende.HQ-cut.avi"
	elif echo "$film_ohne_anfang" | grep -q ".mp4"; then
		outputfile="$output/$film_ohne_ende-cut.mp4"
	else
		outputfile="$output/$film_ohne_ende-cut.avi"
	fi
fi

function ende ()
{
fpsjs=$(($fps*1000))
cat << EOF

//** Postproc **
app.video.setPostProc(3,3,0);
app.video.setFps1000($fpsjs);

//** Filters **

//** Video Codec conf **
app.video.codec("$vidcodec","CQ=4","0 ");

//** Audio **
app.audio.reset();
app.audio.codec("copy",128,0,"");
app.audio.normalizeMode=0;
app.audio.normalizeValue=0;
app.audio.delay=0;
app.audio.mixer("NONE");
app.audio.scanVBR();
app.setContainer("AVI");
setSuccess(app.save("$outputfile"));
//app.Exit();

//End of script
EOF
}

function ende_new ()
{
fpsjs=$(($fps*1000))
cat << EOF

//** Postproc **
app.video.setPostProc(3,3,0);
app.video.fps1000=$fpsjs;

//** Filters **

//** Video Codec conf **
app.video.codec("$vidcodec","CQ=4","0 ");

//** Audio **
app.audio.reset();
app.audio.codec("copy",128,0,"");
app.audio.normalizeMode=0;
app.audio.normalizeValue=0;
app.audio.delay=0;
app.audio.mixer="NONE";
app.audio.scanVBR=""
app.setContainer="AVI";
setSuccess(app.save("$outputfile"));
//app.Exit();

//End of script
EOF
}

if [ "$ad_version" == "old" ]; then
	ende >> "$tmp/avidemux.js"
else
	ende_new >> "$tmp/avidemux.js"
fi

echo "Übergebe die Cuts nun an avidemux"

#if [ "$aspect" == "43" ]; then
if [ "$smart" == "yes" ]; then
	if [ "$verbose" == "yes" ]; then
#		nice -n 15 
		$CutProg --nogui --force-smart --run "$tmp/avidemux.js" --quit
	else
#		nice -n 15 
		$CutProg --nogui --force-smart --run "$tmp/avidemux.js" --quit >> /dev/null
	fi
#elif [ "$aspect" == "169" ]; then
elif [ "$smart" == "no" ]; then
	if [ "$verbose" == "yes" ]; then
#		nice -n 15 
		$CutProg --nogui --run "$tmp/avidemux.js" --quit
	else
#		nice -n 15 
		$CutProg --nogui --run "$tmp/avidemux.js" --quit >> /dev/null
	fi
fi

if [ -f "$outputfile" ]; then
	echo -n -e $outputfile
	echo -e " wurde erstellt"
	if [ "$delete" == "yes" ]; then
		echo "Lösche Quellvideo."	
		if [ $decoded == "yes" ]; then
#			nice -n 15 
			rm -rf "$output/$film"
		else
			#nice -n 15 rm -rf "$film"
#			nice -n 15 
			mv "$film" "$delfolder"
		fi
	fi
else
	echo -e "Avidemux muss einen Fehler verursacht haben"
	if [ $HaltByErrors == "yes" ]; then
		exit 1
	else
		continue=1
	fi
fi
}

#Hier wird nun, wenn gewünscht, eine Bewertung für die Cutlist abgegeben
function bewertung ()
{
echo ""
echo "Sie können nun eine Bewertung für die Cutlist abgeben."
echo "Folgende Noten stehen zur verfügung:"
echo "[0] Test (schlechteste Wertung)"
echo "[1] Anfang und Ende geschnitten"
echo "[2] +/- 5 Sekunden"
echo "[3] +/- 1 Sekunde"
echo "[4] Framegenau"
echo "[5] Framegenau und keine doppelten Szenen"
echo ""
echo "Sollten Sie für diese Cutlist keine Bewertung abgeben wollen,"
echo "drücken Sie einfach ENTER."
echo -n "Note: "
note=""
read note
while [ ! "$note" == "" ] && [ "$note" -gt "5" ]; do
	note=""
	echo -e "Ungültige Eingabe, bitte nochmal:"
	read note
done

if [ "$note" == "" ]; then
	echo "Für diese Cutlist wird keine Bewertung abgegeben."
else
	echo -n "Übermittle Bewertung für $CUTLIST -->"
	if [ "$personal" == "yes" ]; then
		wget -q -O "$tmp/rate.php" "${personalurl}rate.php?rate=$id&rating=$note&userid=$cutlistuser&version=0.9.8.7"
	else
		wget -q -O "$tmp/rate.php" "http://cutlist.at/rate.php?rate=$id&rating=$note&userid=$user&version=0.9.8.7"
	fi
	sleep 1
	if [ -f "$tmp/rate.php" ]; then
		if cat "$tmp/rate.php" | grep -q "Cutlist nicht von hier. Bewertung abgelehnt."; then
			echo -e " False"	
			echo -e " Die Cutlist ist nicht von http://cutlist.at und kann nicht bewertet werden."
		elif cat "$tmp/rate.php" | grep -q "Du hast schon eine Bewertung abgegeben oder Cutlist selbst hochgeladen."; then
			echo -e " False"
			echo -e "Du hast für die Cutlist schonmal eine Bewertung abgegeben oder sie selbst hochgeladen."
		elif cat "$tmp/rate.php" | grep -q "Sie haben diese Liste bereits bewertet"; then
			echo -e " False"
			echo -e "Du hast für die Cutlist schonmal eine Bewertung abgegeben oder sie selbst hochgeladen."
		elif cat "$tmp/rate.php" | grep -q "Cutlist wurde bewertet"; then
			echo -e "Okay"
			echo -e "Cutlist wurde bewertet"
		fi
	else
		echo -e "False"
		echo -e "Bewertung fehlgeschlagen."
	fi
fi
}

#Hier wird ein Otrkey-File dekodiert, falls es gewünscht ist
function decode ()
{
if echo $i | grep -q .otrkey; then
	if [ ! "$email_checked" == "yes" ]; then
		if [ "$email" == "" ]; then
			echo -e "Kann nicht dekodieren da keine EMail-Adresse angegeben wurde!"
			exit 1
		elif [ "$password" == "" ]; then
			echo -e "Kann nicht dekodieren da kein Passwort angegeben wurde!" #
			exit 1
		else
			email_checked=yes
		fi
	fi
	echo "Decodiere Datei --> "
#	nice -n 15 
	$decoder -e "$email" -p "$password" -q -f -i "$i" -o "$output"
	otrkey=$i
	decoded=yes
else
	decoded=no
fi
if [ "$delete" == "yes" ]; then
#	echo "Lösche OtrKey"
	rm -rf "$otrkey"
fi
}

#Hier werden nun die temporären Dateien gelöscht
function del_tmp ()
{
if [ "$tmp" == "" ] || [ "$tmp" == "/" ] || [ "$tmp" == "/home" ]; then
	echo -e "Achtung, bitte überprüfen Sie die Einstellung von \$tmp"
	exit 1
fi
#echo "Lösche temporäre Dateien"
#echo $tmp
rm -rf "$tmp"/*
}


if [ "$warn" == "yes" ]; then
	warnung
fi
# datei #funktion Hinweis Eingabeformat
#del_tmp

#if [ "$server" == "0" ]; then
# echo "Verwende http://cutlist.de als Server."
#elif [ "$server" == "1" ]; then
# echo "Verwende http://cutlist.at als Server"
#elif [ "$server" == "2" ]; then
# echo "Verwende http://cutlist.mbod.net als Server"
#fi
software
for i in "${input[@]}"; do
	test
	del_tmp
	decode
	name
	if [ "$UseLocalCutlist" == "yes" ]; then
		local
	fi
	while true; do
		if [ "$UseLocalCutlist" == "no" ] || [ "$vorhanden" == "no" ]; then
			load
		fi
		if [ "$continue" == "0" ]; then
			format
		fi
		#if [ "$continue" == "0" ]; then
		#	aspectratio
		#fi
		if [ "$continue" == "0" ]; then
			fps
		fi
		if [ "$continue" == "0" ]; then
			cutlist_error
		fi
		if [ "$error_found" == "1" ] && [ "$toprated" == "no" ]; then
			echo -e "In der Cutlist wurde ein Fehler gefunden, soll sie verwendet werden? [y|n]"
			read error_antwort
			if [ "$error_antwort" == "y" ]; then
				echo -e "Verwende die Cutlist trotz Fehler!"
				break
			else
				echo "Bitte neue Cutlist wählen!"
			fi
		else
			break
		fi
		if [ "$error_found" == "1" ] && [ "$toprated" == "yes" ]; then
			break
		fi
	done
	if [ "$CutProg" = "avisplit" ] && [ $continue == "0" ]; then
		if [ "$date_okay" = "yes" ]; then
			time1
		elif [ "$date_okay" = "no" ]; then
			time2
		fi
		if [ "$overwrite" == "no" ]; then
			if [ ! -f "$output/$film_ohne_ende-cut.avi" ]; then
				split
			else
				echo -e "Die Ausgabedatei existiert bereits!"
				if [ $HaltByErrors == "yes" ]; then
					exit 1
				else
					continue=1
				fi
			fi
		fi
		if [ "$overwrite" == "yes" ]; then
			split
		fi
	fi
	if [ "$CutProg" = "avidemux" ] || [ "$CutProg" = "avidemux2" ] || [ "$CutProg" = "avidemux2_cli" ] || [ "$CutProg" = "avidemux2_qt4" ] || [ "$CutProg" = "avidemux2_gtk" ] && [ $continue == "0" ]; then
		if [ "$overwrite" == "no" ]; then
			if [ ! -f "$output/$film_ohne_ende-cut.avi" ]; then
				demux
			else
				echo -e "Die Ausgabedatei existiert bereits!"
				if [ $HaltByErrors == "yes" ]; then
					exit 1
				else
					continue=1
				fi
			fi
		fi
		if [ "$overwrite" == "yes" ]; then
			demux
		fi
	fi
	if [ "$UseLocalCutlist" == "no" ] && [ "$bewertung" == "yes" ] && [ ! "$continue" == "1" ]; then
		if [ "$play" == "no" ]; then
			bewertung
		elif [ "$play" == "yes" ]; then
			echo "Starte nun den gewählten Videoplayer"
			sleep 1
			$player "$outputfile"
			bewertung
		fi
	fi
	if [ "$decoded" == "yes" ]; then
		rm -rf "$output/$film"
	fi
	del_tmp
	continue=0
done